/**
 * 自定义JSON序列化工具
 * 支持Date、BigInt、undefined、null等特殊类型的序列化
 * 用于替代SuperJSON模块，避免ES模块兼容性问题
 */

// 在Node.js环境中使用Buffer来计算字符串长度

/**
 * 序列化对象为JSON字符串
 * @param obj 要序列化的对象
 * @returns 序列化后的JSON字符串
 */
export function stringify(obj: any): string {
    return JSON.stringify(obj, (_key, value) => {
        // 处理Date对象
        if (value instanceof Date) {
            return {
                __type: 'Date',
                __value: value.toISOString()
            };
        }
        // 处理BigInt
        if (typeof value === 'bigint') {
            return {
                __type: 'BigInt',
                __value: value.toString()
            };
        }
        // 处理undefined（转换为null）
        if (value === undefined) {
            return null;
        }
        // 处理NaN
        if (typeof value === 'number' && isNaN(value)) {
            return {
                __type: 'NaN',
                __value: null
            };
        }
        // 处理Infinity
        if (typeof value === 'number' && !isFinite(value)) {
            return {
                __type: 'Infinity',
                __value: value > 0 ? 'positive' : 'negative'
            };
        }
        // 处理RegExp
        if (value instanceof RegExp) {
            return {
                __type: 'RegExp',
                __value: {
                    source: value.source,
                    flags: value.flags
                }
            };
        }
        // 处理Map
        if (value instanceof Map) {
            return {
                __type: 'Map',
                __value: Array.from(value.entries())
            };
        }
        // 处理Set
        if (value instanceof Set) {
            return {
                __type: 'Set',
                __value: Array.from(value)
            };
        }
        return value;
    });
}

/**
 * 反序列化JSON字符串为对象
 * @param json JSON字符串
 * @returns 反序列化后的对象
 */
export function parse(json: string): any {
    return JSON.parse(json, (_key, value) => {
        // 处理自定义类型标记
        if (value && typeof value === 'object' && '__type' in value) {
            switch (value.__type) {
                case 'Date':
                    return new Date(value.__value);
                case 'BigInt':
                    return BigInt(value.__value);
                case 'NaN':
                    return NaN;
                case 'Infinity':
                    return value.__value === 'positive' ? Infinity : -Infinity;
                case 'RegExp':
                    return new RegExp(value.__value.source, value.__value.flags);
                case 'Map':
                    return new Map(value.__value);
                case 'Set':
                    return new Set(value.__value);
                default:
                    return value;
            }
        }
        return value;
    });
}

/**
 * 深度克隆对象
 * @param obj 要克隆的对象
 * @returns 克隆后的对象
 */
export function clone<T>(obj: T): T {
    return parse(stringify(obj));
}

/**
 * 检查对象是否可以安全序列化
 * @param obj 要检查的对象
 * @returns 是否可以安全序列化
 */
export function isSerializable(obj: any): boolean {
    try {
        stringify(obj);
        return true;
    } catch (error) {
        return false;
    }
}

/**
 * 获取序列化后的大小（字节）
 * @param obj 要检查的对象
 * @returns 序列化后的大小
 */
export function getSerializedSize(obj: any): number {
    const serialized = stringify(obj);
    return Buffer.byteLength(serialized, 'utf8');
} 